1. Technical Field
The present invention is directed to an apparatus and method for rapidly creating instruction groups for explicitly parallel architectures. More particularly, the present invention is directed to an apparatus and method for creating instruction groups for the IA64 architecture.
2. Description of Related Art
Explicitly parallel architectures, such as IA64, require the compiler (or assembler programmer) tog identify instructions that can be run safely in parallel. A group of such instructions is called an instruction group. IA64 allows instruction groups of arbitrary size and theoretically all instructions within the group could be executed concurrently. However, any given implementation of the architecture, e.g., Itanium, has resource restrictions that limit the number and types of instructions that can be executed in parallel. Such restrictions include the number and type of execution units and the number of instruction packages (bundles) that can be dispatched concurrently.
For static compilers, long compile times are undesirable but minimizing compile time usually is not of paramount importance. However, dynamic or Just-In-Time compilers may become unusable if their compile times are elongated. Because the compilation typically occurs during the invocation of a method/function, compile time becomes a direct component of response time.
Thus, it would be beneficial to have an apparatus and method for quickly creating instruction groups that will maximize instruction level parallelism for any given implementation of an explicitly parallel architecture, and in particular IA64 architectures.
The present invention provides a mechanism by which instruction groups may be rapidly formed during the compilation of a computer program. With the present invention, it is assumed that a previous compilation phase has generated a stream of intermediate instructions that represents instructions that are arranged in natural program order. The intermediate instructions identify the instruction type and identify all sources and target registers. Additionally, each instruction has a xe2x80x9choistxe2x80x9d field that is initialized to zero.
With the present invention, prior to performing the instruction group creation, the apparatus and method of the present invention gathers information about the underlying architecture for use in the instruction group creation phase. The information gathered includes the number of each type of execution unit available and the number of bundles that can be dispatched concurrently by the architecture.
The instruction group creation of the present invention includes three phases: a first phase for performing initial grouping, a second phase for hosting instructions from further down in the program instruction order if the instruction is not able to be added during the initial grouping phase, and a third optional phase for counting the number of bundles formed to thereby inform a Just-In-Time compiler of the amount of space need to be allocated in a code buffer. Other features and advantages of the present invention will be described in, or will become apparent in view of, the following detailed description of the preferred embodiments.